home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Languages / MPW Oberon 2.1168 / OInterfaces / MoviesFormat.mod < prev    next >
Encoding:
Text File  |  1995-08-10  |  14.0 KB  |  457 lines  |  [TEXT/MPS ]
  1. (*
  2.      File:        MoviesFormat.mod
  3.  
  4.      Contains:    QuickTime Interfaces.
  5.  
  6.      Version:    Technology:    QuickTime 2.0
  7.                  Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs.applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. *)
  19.  
  20. (*$TAGS-*)
  21. (*$CALLING PASCAL*)
  22. MODULE MoviesFormat;
  23.  
  24. IMPORT SYSTEM, Types, ImageCompression, Movies;
  25.  
  26. (* $PUSH*)
  27. (* $ALIGN MAC68K*)
  28. (* $LibExport+*)
  29.  
  30. CONST
  31.     kMovieVersion*                = 0;                            (* version number of the format here described *)
  32.  
  33.  
  34. TYPE
  35.     MoviesUserData* = RECORD
  36.         size*:                    LONGINT;                                (* size of this user data *)
  37.         udType*:                    LONGINT;                                (* type of user data *)
  38.         data*:                    (*ΔΔPACKEDΔΔ*) ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF CHAR;            (* the user data *)
  39.     END;
  40.  
  41.     UserDataAtom* = RECORD
  42.         size*:                    LONGINT;
  43.         atomType*:                LONGINT;
  44.         userData*:                ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF MoviesUserData;
  45.     END;
  46.  
  47. (* MoviesDataDescription tells us where the data for the movie or track lives.
  48.    The data can follow the directory, be in the datafork of the same file as the directory resource,
  49.    be in the resource fork of the same file as the directory resource, be in another file in the
  50.    data fork or resource fork, or require a specific bottleneck to fetch the data. *)
  51. (****************************************
  52. *
  53. *   MediaDirectory information -
  54. *        The MediaDirectory is tightly coupled to the data.
  55. *
  56. ****************************************)
  57.     SampleDescriptionAtom* = RECORD
  58.         size*:                    LONGINT;
  59.         atomType*:                LONGINT;                                (** = LONG("stsd") *)
  60.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  61.         numEntries*:                LONGINT;
  62.         sampleDescTable*:        ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF Movies.SampleDescription;
  63.     END;
  64.  
  65. (* TimeToSampleNum maps physical sample time to physical sample number. *)
  66.     TimeToSampleNum* = RECORD
  67.         sampleCount*:            LONGINT;
  68.         sampleDuration*:            Movies.TimeValue;
  69.     END;
  70.  
  71.     TimeToSampleNumAtom* = RECORD
  72.         size*:                    LONGINT;
  73.         atomType*:                LONGINT;                                (** = LONG("stts") *)
  74.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  75.         numEntries*:                LONGINT;
  76.         timeToSampleNumTable*:    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF TimeToSampleNum;
  77.     END;
  78.  
  79. (* SyncSamples is a list of the physical samples which are self contained. *)
  80.     SyncSampleAtom* = RECORD
  81.         size*:                    LONGINT;
  82.         atomType*:                LONGINT;                                (** = LONG("stss") *)
  83.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  84.         numEntries*:                LONGINT;
  85.         syncSampleTable*:        ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;
  86.     END;
  87.  
  88. (* SampleToChunk maps physical sample number to chunk number. *)
  89. (* same as SampleToChunk, but redundant first sample is removed *)
  90.     SampleToChunk* = RECORD
  91.         firstChunk*:                LONGINT;
  92.         samplesPerChunk*:        LONGINT;
  93.         sampleDescriptionID*:    LONGINT;
  94.     END;
  95.  
  96.     SampleToChunkAtom* = RECORD
  97.         size*:                    LONGINT;
  98.         atomType*:                LONGINT;                                (** = LONG("stsc") *)
  99.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  100.         numEntries*:                LONGINT;
  101.         sampleToChunkTable*:        ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF SampleToChunk;
  102.     END;
  103.  
  104.     ChunkOffsetAtom* = RECORD
  105.         size*:                    LONGINT;
  106.         atomType*:                LONGINT;                                (** = LONG("stco") *)
  107.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  108.         numEntries*:                LONGINT;
  109.         chunkOffsetTable*:        ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;
  110.     END;
  111.  
  112.     SampleSizeAtom* = RECORD
  113.         size*:                    LONGINT;
  114.         atomType*:                LONGINT;                                (** = LONG("stsz") *)
  115.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  116.         sampleSize*:                LONGINT;
  117.         numEntries*:                LONGINT;
  118.         sampleSizeTable*:        ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF LONGINT;
  119.     END;
  120.  
  121.     ShadowSync* = RECORD
  122.         fdSampleNum*:            LONGINT;
  123.         syncSampleNum*:            LONGINT;
  124.     END;
  125.  
  126.     ShadowSyncAtom* = RECORD
  127.         size*:                    LONGINT;
  128.         atomType*:                LONGINT;                                (** = LONG("stsz") *)
  129.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  130.         numEntries*:                LONGINT;
  131.         shadowSyncTable*:        ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF ShadowSync;
  132.     END;
  133.  
  134.     SampleTableAtom* = RECORD
  135.         size*:                    LONGINT;
  136.         atomType*:                LONGINT;                                (** = LONG("stbl") *)
  137.         sampleDescription*:        SampleDescriptionAtom;
  138.         timeToSampleNum*:        TimeToSampleNumAtom;
  139.         sampleToChunk*:            SampleToChunkAtom;
  140.         syncSample*:                SyncSampleAtom;
  141.         sampleSize*:                SampleSizeAtom;
  142.         chunkOffset*:            ChunkOffsetAtom;
  143.         shadowSync*:                ShadowSyncAtom;
  144.     END;
  145.  
  146.     PublicHandlerInfo* = RECORD
  147.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  148.         componentType*:            LONGINT;
  149.         componentSubType*:        LONGINT;
  150.         componentManufacturer*:    LONGINT;
  151.         componentFlags*:            LONGINT;
  152.         componentFlagsMask*:        LONGINT;
  153.         componentName*:            (*ΔΔPACKEDΔΔ*) ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF CHAR;
  154.     END;
  155.  
  156.     HandlerAtom* = RECORD
  157.         size*:                    LONGINT;
  158.         atomType*:                LONGINT;                                (** = LONG("hdlr") *)
  159.         hInfo*:                    PublicHandlerInfo;
  160.     END;
  161.  
  162. (* a data reference is a private structure *)
  163.     DataRefAtom* = LONGINT;
  164.  
  165.     DataInfoAtom* = RECORD
  166.         size*:                    LONGINT;
  167.         atomType*:                LONGINT;                                (** = LONG("dinf") *)
  168.         dataRef*:                DataRefAtom;
  169.     END;
  170.  
  171.     RgnAtom* = RECORD
  172.         size*:                    LONGINT;
  173.         atomType*:                LONGINT;
  174.         rgnSize*:                INTEGER;
  175.         rgnBBox*:                Types.Rect;
  176.         data*:                    (*ΔΔPACKEDΔΔ*) ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF CHAR;
  177.     END;
  178.  
  179.     MatteCompressedAtom* = RECORD
  180.         size*:                    LONGINT;
  181.         atomType*:                LONGINT;
  182.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  183.         matteImageDescription*:    ImageCompression.ImageDescription;
  184.         matteData*:                (*ΔΔPACKEDΔΔ*) ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF CHAR;
  185.     END;
  186.  
  187.     MatteAtom* = RECORD
  188.         size*:                    LONGINT;
  189.         atomType*:                LONGINT;
  190.         aCompressedMatte*:        MatteCompressedAtom;
  191.     END;
  192.  
  193.     ClippingAtom* = RECORD
  194.         size*:                    LONGINT;
  195.         atomType*:                LONGINT;
  196.         aRgnClip*:                RgnAtom;
  197.     END;
  198.  
  199. (***********************
  200. * Movies.Media Info Example Structures
  201. ***********************)
  202.     VideoMediaInfoHeader* = RECORD
  203.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  204.         graphicsMode*:            INTEGER;                                (* for QD - transfer mode *)
  205.         opColorRed*:                INTEGER;                                (* opcolor for transfer mode *)
  206.         opColorGreen*:            INTEGER;
  207.         opColorBlue*:            INTEGER;
  208.     END;
  209.  
  210.     VideoMediaInfoHeaderAtom* = RECORD
  211.         size*:                    LONGINT;                                (* size of Movies.Media info *)
  212.         atomType*:                LONGINT;                                (** = LONG("vmhd") *)
  213.         vmiHeader*:                VideoMediaInfoHeader;
  214.     END;
  215.  
  216.     VideoMediaInfo* = RECORD
  217.         size*:                    LONGINT;                                (* size of Movies.Media info *)
  218.         atomType*:                LONGINT;                                (** = LONG("minf") *)
  219.         header*:                    VideoMediaInfoHeaderAtom;
  220.         dataHandler*:            HandlerAtom;
  221.         dataInfo*:                DataInfoAtom;
  222.         sampleTable*:            SampleTableAtom;
  223.     END;
  224.  
  225.     SoundMediaInfoHeader* = RECORD
  226.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  227.         balance*:                INTEGER;
  228.         rsrvd*:                    INTEGER;
  229.     END;
  230.  
  231.     SoundMediaInfoHeaderAtom* = RECORD
  232.         size*:                    LONGINT;                                (* size of Movies.Media info *)
  233.         atomType*:                LONGINT;                                (** = LONG("vmhd") *)
  234.         smiHeader*:                SoundMediaInfoHeader;
  235.     END;
  236.  
  237.     SoundMediaInfo* = RECORD
  238.         size*:                    LONGINT;                                (* size of Movies.Media info *)
  239.         atomType*:                LONGINT;                                (** = LONG("minf") *)
  240.         header*:                    SoundMediaInfoHeaderAtom;
  241.         dataHandler*:            HandlerAtom;
  242.         dataReference*:            DataRefAtom;
  243.         sampleTable*:            SampleTableAtom;
  244.     END;
  245.  
  246. (* whatever data the media handler needs goes after the atomType *)
  247.     MediaInfo* = RECORD
  248.         size*:                    LONGINT;
  249.         atomType*:                LONGINT;
  250.     END;
  251.  
  252. (***********************
  253. * Movies.Media Directory Structures
  254. ***********************)
  255.     MediaHeader* = RECORD
  256.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  257.         creationTime*:            LONGINT;                                (* seconds since Jan 1904 when directory was created *)
  258.         modificationTime*:        LONGINT;                                (* seconds since Jan 1904 when directory was appended *)
  259.         timeScale*:                Movies.TimeValue;                                (* start time for Movies.Media (Movies.Media time) *)
  260.         duration*:                Movies.TimeValue;                                (* length of Movies.Media (Movies.Media time) *)
  261.         language*:                INTEGER;
  262.         quality*:                INTEGER;
  263.     END;
  264.  
  265.     MediaHeaderAtom* = RECORD
  266.         size*:                    LONGINT;
  267.         atomType*:                LONGINT;
  268.         header*:                    MediaHeader;
  269.     END;
  270.  
  271.     MediaDirectory* = RECORD
  272.         size*:                    LONGINT;
  273.         atomType*:                LONGINT;                                (** = LONG("mdia") *)
  274.         mediaHeader*:            MediaHeaderAtom;                        (* standard Movies.Media information *)
  275.         mediaHandler*:            HandlerAtom;
  276.         mediaInfo*:                MediaInfo;
  277.     END;
  278.  
  279. (***********************
  280. * Movies.Track Structures
  281. ***********************)
  282.  
  283. CONST
  284.     TrackEnable*                    = ASH(1,0);
  285.     TrackInMovie*                = ASH(1,1);
  286.     TrackInPreview*                = ASH(1,2);
  287.     TrackInPoster*                = ASH(1,3);
  288.  
  289.  
  290. TYPE
  291.     TrackHeader* = RECORD
  292.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  293.         creationTime*:            LONGINT;                                (* seconds since Jan 1904 when directory was created *)
  294.         modificationTime*:        LONGINT;                                (* seconds since Jan 1904 when directory was appended *)
  295.         trackID*:                LONGINT;
  296.         reserved1*:                LONGINT;
  297.         duration*:                Movies.TimeValue;                                (* length of track (track time) *)
  298.         reserved2*:                LONGINT;
  299.         reserved3*:                LONGINT;
  300.         layer*:                    INTEGER;
  301.         alternateGroup*:            INTEGER;
  302.         volume*:                    INTEGER;
  303.         reserved4*:                INTEGER;
  304.         matrix*:                    ImageCompression.MatrixRecord;
  305.         trackWidth*:                Types.Fixed;
  306.         trackHeight*:            Types.Fixed;
  307.     END;
  308.  
  309.     TrackHeaderAtom* = RECORD
  310.         size*:                    LONGINT;                                (* size of track header *)
  311.         atomType*:                LONGINT;                                (** = LONG("tkhd") *)
  312.         header*:                    TrackHeader;
  313.     END;
  314.  
  315.     EditListType* = RECORD
  316.         trackDuration*:            Movies.TimeValue;
  317.         mediaTime*:                Movies.TimeValue;
  318.         mediaRate*:                Types.Fixed;
  319.     END;
  320.  
  321.     EditListAtom* = RECORD
  322.         size*:                    LONGINT;
  323.         atomType*:                LONGINT;                                (** = elst *)
  324.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  325.         numEntries*:                LONGINT;
  326.         editListTable*:            ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF EditListType;
  327.     END;
  328.  
  329.     EditsAtom* = RECORD
  330.         size*:                    LONGINT;
  331.         atomType*:                LONGINT;                                (** = edts *)
  332.         editList*:                EditListAtom;
  333.     END;
  334.  
  335.     TrackLoadSettings* = RECORD
  336.         preloadStartTime*:        Movies.TimeValue;
  337.         preloadDuration*:        Movies.TimeValue;
  338.         preloadFlags*:            LONGINT;
  339.         defaultHints*:            LONGINT;
  340.     END;
  341.  
  342.     TrackLoadSettingsAtom* = RECORD
  343.         size*:                    LONGINT;
  344.         atomType*:                LONGINT;                                (** = load *)
  345.         settings*:                TrackLoadSettings;
  346.     END;
  347.  
  348.     TrackDirectory* = RECORD
  349.         size*:                    LONGINT;
  350.         atomType*:                LONGINT;                                (** = LONG("trak") *)
  351.         trackHeader*:            TrackHeaderAtom;                        (* standard track information *)
  352.         trackClip*:                ClippingAtom;
  353.         edits*:                    EditsAtom;
  354.         media*:                    MediaDirectory;
  355.         userData*:                UserDataAtom;                            (* space for extending with new data types *)
  356.     END;
  357.  
  358. (****************************************
  359. *
  360. *   MovieDirectory -
  361. *        The MovieDirectory is the top level structure which
  362. *        holds the TrackInstance describing where the
  363. *        TrackDirectories are.
  364. *
  365. ****************************************)
  366.     MovieHeader* = RECORD
  367.         flags*:                    LONGINT;                                (* 1 byte of version / 3 bytes of flags *)
  368.         creationTime*:            LONGINT;                                (* seconds since Jan 1904 when directory was created *)
  369.         modificationTime*:        LONGINT;                                (* seconds since Jan 1904 when directory was appended *)
  370.         timeScale*:                Movies.TimeValue;                                (* Sound.Time specifications *)
  371.         duration*:                Movies.TimeValue;
  372.         preferredRate*:            Types.Fixed;                                    (* rate at which to play this movie *)
  373.         preferredVolume*:        INTEGER;                                (* volume to play movie at *)
  374.         reserved1*:                INTEGER;
  375.         preferredLong1*:            LONGINT;
  376.         preferredLong2*:            LONGINT;
  377.         matrix*:                    ImageCompression.MatrixRecord;
  378.         previewTime*:            Movies.TimeValue;                                (* time in track the proxy begins (track time) *)
  379.         previewDuration*:        Movies.TimeValue;                                (* how long the proxy lasts (track time) *)
  380.         posterTime*:                Movies.TimeValue;                                (* time in track the proxy begins (track time) *)
  381.         selectionTime*:            Movies.TimeValue;                                (* time in track the proxy begins (track time) *)
  382.         selectionDuration*:        Movies.TimeValue;                                (* time in track the proxy begins (track time) *)
  383.         currentTime*:            Movies.TimeValue;                                (* time in track the proxy begins (track time) *)
  384.         nextTrackID*:            LONGINT;                                (* next value to use for a TrackID *)
  385.     END;
  386.  
  387.     MovieHeaderAtom* = RECORD
  388.         size*:                    LONGINT;
  389.         atomType*:                LONGINT;                                (** = LONG("mvhd") *)
  390.         header*:                    MovieHeader;
  391.     END;
  392.  
  393.     MovieDirectory* = RECORD
  394.         size*:                    LONGINT;
  395.         atomType*:                LONGINT;                                (** = LONG("moov") *)
  396.         header*:                    MovieHeaderAtom;
  397.         movieClip*:                ClippingAtom;
  398.         (* Movies.Track Directories *)
  399.         track*:            RECORD
  400.                 trackDirectory*:                    TrackDirectory;                    (* Movies.Track directory information *)
  401.             END;
  402.  
  403.  
  404.         (* User data for Movies.Movie *)
  405.         userData*:                UserDataAtom;                            (* space for user extensions *)
  406.     END;
  407.  
  408.  
  409. CONST
  410. (* some system defined format IDs *)
  411.     MOVIE_TYPE*                    = LONG("moov");
  412.     TRACK_TYPE*                    = LONG("trak");
  413.     MEDIA_TYPE*                    = LONG("mdia");
  414.     VIDEO_TYPE*                    = LONG("vide");
  415.     SOUND_TYPE*                    = LONG("soun");
  416.  
  417. (* atom id's *)
  418.     MovieAID*                    = LONG("moov");
  419.     MovieHeaderAID*                = LONG("mvhd");
  420.     ClipAID*                        = LONG("clip");
  421.     RgnClipAID*                    = LONG("crgn");
  422.     MatteAID*                    = LONG("matt");
  423.     MatteCompAID*                = LONG("kmat");
  424.     TrackAID*                    = LONG("trak");
  425.     UserDataAID*                    = LONG("udta");
  426.     TrackHeaderAID*                = LONG("tkhd");
  427.     EditsAID*                    = LONG("edts");
  428.     EditListAID*                    = LONG("elst");
  429.     MediaAID*                    = LONG("mdia");
  430.     MediaHeaderAID*                = LONG("mdhd");
  431.     MediaInfoAID*                = LONG("minf");
  432.     VideoMediaInfoHeaderAID*        = LONG("vmhd");
  433.     SoundMediaInfoHeaderAID*        = LONG("smhd");
  434.     GenericMediaInfoHeaderAID*    = LONG("gmhd");
  435.     GenericMediaInfoAID*            = LONG("gmin");
  436.     DataInfoAID*                    = LONG("dinf");
  437.     DataRefAID*                    = LONG("dref");
  438.     SampleTableAID*                = LONG("stbl");
  439.     STSampleDescAID*                = LONG("stsd");
  440.     STTimeToSampAID*                = LONG("stts");
  441.     STSyncSampleAID*                = LONG("stss");
  442.     STSampleToChunkAID*            = LONG("stsc");
  443.     STShadowSyncAID*                = LONG("stsh");
  444.     HandlerAID*                    = LONG("hdlr");
  445.     STSampleSizeAID*                = LONG("stsz");
  446.     STChunkOffsetAID*            = LONG("stco");
  447.     DataRefContainerAID*            = LONG("drfc");
  448.     TrackReferenceAID*            = LONG("tref");
  449.     ColorTableAID*                = LONG("ctab");
  450.     LoadSettingsAID*                = LONG("load");
  451.  
  452.  
  453. (* $ALIGN RESET*)
  454. (* $POP*)
  455.  
  456.  END MoviesFormat.
  457.